home *** CD-ROM | disk | FTP | other *** search
/ MacWorld Secrets (4th Edition) / Mac Secrets CD 4th Ed.toast / Apple Advanced Technologies / Apple Speech Technologies 1.5 / PlainTalk Developer Info / Speech Recognition Manager SDK / SR 1.5 Interfaces & Lib / SpeechRecognition.p < prev    next >
Text File  |  1996-10-29  |  21KB  |  428 lines
  1. {
  2.      File:        SpeechRecognition.p
  3.  
  4.      Contains:    Apple Speech Recognition Toolbox Interfaces.
  5.  
  6.      Version:    Technology:    PlainTalk 1.5
  7.  
  8.                  Release:    PlainTalk Developer Release
  9.  
  10.      Copyright:    © 1984-1996 by Apple Computer, Inc.
  11.  
  12.                  All rights reserved.
  13.  
  14.      Bugs?:        If you find a problem with this file, send the file and version
  15.                  information (from above) and the problem description to:
  16.  
  17.                      Internet:    apple.bugs@applelink.apple.com
  18.                      AppleLink:    APPLE.BUGS
  19.  
  20. }
  21. {$IFC UNDEFINED UsingIncludes}
  22. {$SETC UsingIncludes := 0}
  23. {$ENDC}
  24.  
  25. {$IFC NOT UsingIncludes}
  26.  UNIT SpeechRecognition;
  27.  INTERFACE
  28. {$ENDC}
  29.  
  30. {$IFC UNDEFINED __SPEECHRECOGNITION__}
  31. {$SETC __SPEECHRECOGNITION__ := 1}
  32.  
  33. {$I+}
  34. {$SETC SpeechRecognitionIncludes := UsingIncludes}
  35. {$SETC UsingIncludes := 1}
  36.  
  37. {$IFC UNDEFINED __MEMORY__}
  38. {$I Memory.p}
  39. {$ENDC}
  40.  
  41. {$PUSH}
  42. {$ALIGN MAC68K}
  43. {$LibExport+}
  44.  
  45.  
  46. CONST
  47.     gestaltSpeechRecognitionVersion = 'srtb';
  48.     gestaltSpeechRecognitionAttr = 'srta';
  49.     gestaltDesktopSpeechRecognition = $00000001;
  50.     gestaltTelephoneSpeechRecognition = $00000002;
  51. {  Error Codes [Speech recognition gets -5100 through -5199]  }
  52.     kSRNotAvailable                = -5100;                        {  the service requested is not avail or applicable  }
  53.     kSRInternalError            = -5101;                        {  a system internal or hardware error condition  }
  54.     kSRComponentNotFound        = -5102;                        {  a needed system resource was not located  }
  55.     kSROutOfMemory                = -5103;                        {  an out of memory error occurred in the toolbox memory space  }
  56.     kSRNotASpeechObject            = -5104;                        {  the object specified is no longer or never was valid  }
  57.     kSRBadParameter                = -5105;                        {  an invalid parameter was specified  }
  58.     kSRParamOutOfRange            = -5106;                        {  when we say 0-100, don't pass in 101.  }
  59.     kSRBadSelector                = -5107;                        {  an unrecognized selector was specified  }
  60.     kSRBufferTooSmall            = -5108;                        {  returned from attribute access functions  }
  61.     kSRNotARecSystem            = -5109;                        {  the object used was not a SRRecognitionSystem  }
  62.     kSRFeedbackNotAvail            = -5110;                        {  there is no feedback window associated with SRRecognizer  }
  63.     kSRCantSetProperty            = -5111;                        {  a non-settable property was specified  }
  64.     kSRCantGetProperty            = -5112;                        {  a non-gettable property was specified  }
  65.     kSRCantSetDuringRecognition    = -5113;                        {  the property can't be set while recognition is in progress -- do before or between utterances.  }
  66.     kSRAlreadyListening            = -5114;                        {  in response to SRStartListening  }
  67.     kSRNotListeningState        = -5115;                        {  in response to SRStopListening  }
  68.     kSRModelMismatch            = -5116;                        {  no acoustical models are avail to match request  }
  69.     kSRNoClientLanguageModel    = -5117;                        {  trying to access a non-specified SRLanguageModel  }
  70.     kSRNoPendingUtterances        = -5118;                        {  nothing to continue search on  }
  71.     kSRRecognitionCanceled        = -5119;                        {  an abort error occurred during search  }
  72.     kSRRecognitionDone            = -5120;                        {  search has finished, but nothing was recognized  }
  73.     kSROtherRecAlreadyModal        = -5121;                        {  another recognizer is modal at the moment, so can't set this recognizer's kSRBlockModally property right now  }
  74.     kSRHasNoSubItems            = -5122;                        {  SRCountItems or related routine was called on an object without subelements -- e.g. a word -- rather than phrase, path, or LM.  }
  75.     kSRSubItemNotFound            = -5123;                        {  returned when accessing a non-existent sub item of a container  }
  76.     kSRLanguageModelTooBig        = -5124;                        {  Cant build language models so big  }
  77.     kSRAlreadyReleased            = -5125;                        {  this object has already been released before  }
  78.     kSRAlreadyFinished            = -5126;                        {  the language model can't be finished twice  }
  79.     kSRWordNotFound                = -5127;                        {  the spelling couldn't be found in lookup(s)  }
  80.     kSRNotFinishedWithRejection    = -5128;                        {  property not found because the LMObj is not finished with rejection  }
  81.     kSRExpansionTooDeep            = -5129;                        {  Language model is left recursive or is embedded too many levels  }
  82.     kSRTooManyElements            = -5130;                        {  Too many elements added to phrase or path or other langauge model object  }
  83.     kSRCantAdd                    = -5131;                        {  Can't add given type of object to the base SRLanguageObject (e.g.in SRAddLanguageObject)     }
  84.     kSRSndInSourceDisconnected    = -5132;                        {  Sound input source is disconnected  }
  85.     kSRCantReadLanguageObject    = -5133;                        {  An error while trying to create new Language object from file or pointer -- possibly bad format  }
  86.                                                                 {  non-release debugging error codes are included here  }
  87.     kSRNotImplementedYet        = -5199;                        {  you'd better wait for this feature in a future release  }
  88. {  Type Definitions  }
  89.  
  90. TYPE
  91.     SRSpeechObject = ^LONGINT;
  92.     SRRecognitionSystem                    = SRSpeechObject;
  93.     SRRecognizer                        = SRSpeechObject;
  94.     SRSpeechSource                        = SRSpeechObject;
  95.     SRRecognitionResult                    = SRSpeechSource;
  96.     SRLanguageObject                    = SRSpeechObject;
  97.     SRLanguageModel                        = SRLanguageObject;
  98.     SRPath                                = SRLanguageObject;
  99.     SRPhrase                            = SRLanguageObject;
  100.     SRWord                                = SRLanguageObject;
  101. {  between 0 and 100  }
  102.     SRSpeedSetting                        = INTEGER;
  103. {  between 0 and 100  }
  104.     SRRejectionLevel                    = INTEGER;
  105. {  When an event occurs, the user supplied proc will be called with a pointer     }
  106. {     to the param passed in and a flag to indicate conditions such                 }
  107. {     as interrupt time or system background time.                                 }
  108.     SRCallBackStructPtr = ^SRCallBackStruct;
  109.     SRCallBackStruct = RECORD
  110.         what:                    LONGINT;                                {  one of notification flags  }
  111.         message:                LONGINT;                                {  contains SRRecognitionResult id  }
  112.         instance:                SRRecognizer;                            {  ID of recognizer being notified  }
  113.         status:                    OSErr;                                    {  result status of last search  }
  114.         flags:                    INTEGER;                                {  non-zero if occurs during interrupt  }
  115.         refCon:                    LONGINT;                                {  user defined - set from SRCallBackParam  }
  116.     END;
  117.  
  118. {  Call back procedure definition  }
  119.     SRCallBackProcPtr = ProcPtr;  { PROCEDURE SRCallBack(VAR param: SRCallBackStruct); }
  120.  
  121.     SRCallBackUPP = UniversalProcPtr;
  122.  
  123. CONST
  124.     uppSRCallBackProcInfo = $000000C0;
  125.  
  126. FUNCTION NewSRCallBackProc(userRoutine: SRCallBackProcPtr): SRCallBackUPP;
  127.     {$IFC NOT GENERATINGCFM }
  128.     INLINE $2E9F;
  129.     {$ENDC}
  130.  
  131. PROCEDURE CallSRCallBackProc(VAR param: SRCallBackStruct; userRoutine: SRCallBackUPP);
  132.     {$IFC NOT GENERATINGCFM}
  133.     INLINE $205F, $4E90;
  134.     {$ENDC}
  135.  
  136. TYPE
  137.     SRCallBackParamPtr = ^SRCallBackParam;
  138.     SRCallBackParam = RECORD
  139.         callBack:                SRCallBackUPP;
  140.         refCon:                    LONGINT;
  141.     END;
  142.  
  143. {  Recognition System Types  }
  144.  
  145. CONST
  146.     kSRDefaultRecognitionSystemID = 0;
  147. {  Recognition System Properties  }
  148.     kSRFeedbackAndListeningModes = 'fbwn';                        {  short: one of kSRNoFeedbackHasListenModes, kSRHasFeedbackHasListenModes, kSRNoFeedbackNoListenModes  }
  149.     kSRRejectedWord                = 'rejq';                        {  the SRWord used to represent a rejection  }
  150.     kSRCleanupOnClientExit        = 'clup';                        {  Boolean: Default is true. The rec system and everything it owns is disposed when the client application quits  }
  151.     kSRNoFeedbackNoListenModes    = 0;                            {  next allocated recognizer has no feedback window and doesn't use listening modes     }
  152.     kSRHasFeedbackHasListenModes = 1;                            {  next allocated recognizer has feedback window and uses listening modes              }
  153.     kSRNoFeedbackHasListenModes    = 2;                            {  next allocated recognizer has no feedback window but does use listening modes      }
  154. {  Speech Source Types  }
  155.     kSRDefaultSpeechSource        = 0;
  156.     kSRLiveDesktopSpeechSource    = 'dklv';                        {  live desktop sound input  }
  157.     kSRCanned22kHzSpeechSource    = 'ca22';                        {  AIFF file based 16 bit, 22.050 KHz sound input  }
  158. {  Notification via Apple Event or Callback  }
  159. {  Notification Flags  }
  160.     kSRNotifyRecognitionBeginning = $00000001;                    {  recognition can begin. client must now call SRContinueRecognition or SRCancelRecognition  }
  161.     kSRNotifyRecognitionDone    = $00000002;                    {  recognition has terminated. result (if any) is available.  }
  162. {  Apple Event selectors  }
  163. {  AppleEvent message class   }
  164.     kAESpeechSuite                = 'sprc';
  165. {  AppleEvent message event ids  }
  166.     kAESpeechDone                = 'srsd';
  167.     kAESpeechDetected            = 'srbd';
  168. {  AppleEvent Parameter ids  }
  169.     keySRRecognizer                = 'krec';
  170.     keySRSpeechResult            = 'kspr';
  171.     keySRSpeechStatus            = 'ksst';
  172. {  AppleEvent Parameter types  }
  173.     typeSRRecognizer            = 'trec';
  174.     typeSRSpeechResult            = 'tspr';
  175. {  SRRecognizer Properties  }
  176.     kSRNotificationParam        = 'noti';                        {  see notification flags below  }
  177.     kSRCallBackParam            = 'call';                        {  type SRCallBackParam  }
  178.     kSRSearchStatusParam        = 'stat';                        {  see status flags below  }
  179.     kSRAutoFinishingParam        = 'afin';                        {  automatic finishing applied on LM for search  }
  180.     kSRForegroundOnly            = 'fgon';                        {  Boolean. Default is true. If true, client recognizer only active when in foreground.     }
  181.     kSRBlockBackground            = 'blbg';                        {  Boolean. Default is false. If true, when client recognizer in foreground, rest of LMs are inactive.     }
  182.     kSRBlockModally                = 'blmd';                        {  Boolean. Default is false. When true, this client's LM is only active LM; all other LMs are inactive. Be nice, don't be modal for long periods!  }
  183.     kSRWantsResultTextDrawn        = 'txfb';                        {  Boolean. Default is true. If true, search results are posted to Feedback window  }
  184.     kSRWantsAutoFBGestures        = 'dfbr';                        {  Boolean. Default is true. If true, client needn't call SRProcessBegin/End to get default feedback behavior  }
  185.     kSRSoundInVolume            = 'volu';                        {  short in [0..100] log scaled sound input power. Can't set this property  }
  186.     kSRReadAudioFSSpec            = 'aurd';                        {  *FSSpec. Specify FSSpec where raw audio is to be read (AIFF format) using kSRCanned22kHzSpeechSource. Reads until EOF  }
  187.     kSRCancelOnSoundOut            = 'caso';                        {  Boolean: Default is true.  If any sound is played out during utterance, recognition is aborted.  }
  188.     kSRSpeedVsAccuracyParam        = 'sped';                        {  SRSpeedSetting between 0 and 100  }
  189. {  0 means more accurate but slower.  }
  190. {  100 means (much) less accurate but faster.  }
  191.     kSRUseToggleListen            = 0;                            {  listen key modes  }
  192.     kSRUsePushToTalk            = 1;
  193.     kSRListenKeyMode            = 'lkmd';                        {  short: either kSRUseToggleListen or kSRUsePushToTalk  }
  194.     kSRListenKeyCombo            = 'lkey';                        {  short: Push-To-Talk key combination; high byte is high byte of event->modifiers, the low byte is the keycode from event->message  }
  195.     kSRListenKeyName            = 'lnam';                        {  Str63: string representing ListenKeyCombo  }
  196.     kSRKeyWord                    = 'kwrd';                        {  Str255: keyword preceding spoken commands in kSRUseToggleListen mode  }
  197.     kSRKeyExpected                = 'kexp';                        {  Boolean: Must the PTT key be depressed or the key word spoken before recognition can occur?  }
  198. {  Operational Status Flags  }
  199.     kSRIdleRecognizer            = $00000001;                    {  engine is not active  }
  200.     kSRSearchInProgress            = $00000002;                    {  search is in progress  }
  201.     kSRSearchWaitForAllClients    = $00000004;                    {  search is suspended waiting on all clients' input  }
  202.     kSRMustCancelSearch            = $00000008;                    {  something has occurred (sound played, non-speech detected) requiring the search to abort  }
  203.     kSRPendingSearch            = $00000010;                    {  we're about to start searching  }
  204. {  Recognition Result Properties  }
  205.     kSRTEXTFormat                = 'TEXT';                        {  raw text in user supplied memory  }
  206.     kSRPhraseFormat                = 'lmph';                        {  SRPhrase containing result words  }
  207.     kSRPathFormat                = 'lmpt';                        {  SRPath containing result phrases or words  }
  208.     kSRLanguageModelFormat        = 'lmfm';                        {  top level SRLanguageModel for post parse  }
  209. {  SRLanguageObject Family Properties  }
  210.     kSRSpelling                    = 'spel';                        {  spelling of a SRWord or SRPhrase or SRPath, or name of a SRLanguageModel  }
  211.     kSRLMObjType                = 'lmtp';                        {  Returns one of SRLanguageObject Types listed below  }
  212.     kSRRefCon                    = 'refc';                        {  4 bytes of user storage  }
  213.     kSROptional                    = 'optl';                        {  Boolean -- true if SRLanguageObject is optional     }
  214.     kSREnabled                    = 'enbl';                        {  Boolean -- true if SRLanguageObject enabled  }
  215.     kSRRepeatable                = 'rptb';                        {  Boolean -- true if SRLanguageObject is repeatable  }
  216.     kSRRejectable                = 'rjbl';                        {  Boolean -- true if SRLanguageObject is rejectable (Recognition System's kSRRejectedWord  }
  217.                                                                 {         object can be returned in place of SRLanguageObject with this property)     }
  218.     kSRRejectionLevel            = 'rjct';                        {  SRRejectionLevel between 0 and 100  }
  219. {  LM Object Types -- returned as kSRLMObjType property of language model objects  }
  220.     kSRLanguageModelType        = 'lmob';                        {  SRLanguageModel  }
  221.     kSRPathType                    = 'path';                        {  SRPath  }
  222.     kSRPhraseType                = 'phra';                        {  SRPhrase  }
  223.     kSRWordType                    = 'word';                        {  SRWord  }
  224. {  a normal and reasonable rejection level  }
  225.     kSRDefaultRejectionLevel    = 50;
  226. { ****************************************************************************** }
  227. {                         NOTES ON USING THE API                                     }
  228. {                                                                                  }
  229. {         All operations (with the exception of SRGetRecognitionSystem) are         }
  230. {         directed toward an object allocated or begot from New, Get and Read         }
  231. {         type calls.                                                                 }
  232. {                                                                                  }
  233. {         There is a simple rule in dealing with allocation and disposal:             }
  234. {                                                                                  }
  235. {         *    all toolbox allocations are obtained from a SRRecognitionSystem         }
  236. {                                                                                  }
  237. {         *    if you obtain an object via New or Get, then you own a reference      }
  238. {             to that object and it must be released via SRReleaseObject when         }
  239. {             you no longer need it                                                 }
  240. {                                                                                  }
  241. {         *    when you receive a SRRecognitionResult object via AppleEvent or         }
  242. {             callback, it has essentially been created on your behalf and so         }
  243. {             you are responsible for releasing it as above                         }
  244. {                                                                                  }
  245. {         *    when you close a SRRecognitionSystem, all remaining objects which         }
  246. {             were allocated with it will be forcefully released and any             }
  247. {             remaining references to those objects will be invalid.                 }
  248. {                                                                                  }
  249. {         This translates into a very simple guideline:                             }
  250. {             If you allocate it or have it allocated for you, you must release     }
  251. {             it.  If you are only peeking at it, then don't release it.             }
  252. {                                                                                  }
  253. { ****************************************************************************** }
  254. {  Opening and Closing of the SRRecognitionSystem  }
  255. FUNCTION SROpenRecognitionSystem(VAR system: SRRecognitionSystem; systemID: OSType): OSErr;
  256.     {$IFC NOT GENERATINGCFM}
  257.     INLINE $303C, $0400, $AA56;
  258.     {$ENDC}
  259. FUNCTION SRCloseRecognitionSystem(system: SRRecognitionSystem): OSErr;
  260.     {$IFC NOT GENERATINGCFM}
  261.     INLINE $303C, $0201, $AA56;
  262.     {$ENDC}
  263. {  Accessing Properties of any Speech Object  }
  264. FUNCTION SRSetProperty(srObject: SRSpeechObject; selector: OSType; property: UNIV Ptr; propertyLen: Size): OSErr;
  265.     {$IFC NOT GENERATINGCFM}
  266.     INLINE $303C, $0802, $AA56;
  267.     {$ENDC}
  268. FUNCTION SRGetProperty(srObject: SRSpeechObject; selector: OSType; property: UNIV Ptr; VAR propertyLen: Size): OSErr;
  269.     {$IFC NOT GENERATINGCFM}
  270.     INLINE $303C, $0803, $AA56;
  271.     {$ENDC}
  272. {  Any object obtained via New or Get type calls must be released  }
  273. FUNCTION SRReleaseObject(srObject: SRSpeechObject): OSErr;
  274.     {$IFC NOT GENERATINGCFM}
  275.     INLINE $303C, $0204, $AA56;
  276.     {$ENDC}
  277. FUNCTION SRGetReference(srObject: SRSpeechObject; VAR newObjectRef: SRSpeechObject): OSErr;
  278.     {$IFC NOT GENERATINGCFM}
  279.     INLINE $303C, $0425, $AA56;
  280.     {$ENDC}
  281. {  SRRecognizer Instance Functions  }
  282. FUNCTION SRNewRecognizer(system: SRRecognitionSystem; VAR recognizer: SRRecognizer; sourceID: OSType): OSErr;
  283.     {$IFC NOT GENERATINGCFM}
  284.     INLINE $303C, $060A, $AA56;
  285.     {$ENDC}
  286. FUNCTION SRStartListening(recognizer: SRRecognizer): OSErr;
  287.     {$IFC NOT GENERATINGCFM}
  288.     INLINE $303C, $020C, $AA56;
  289.     {$ENDC}
  290. FUNCTION SRStopListening(recognizer: SRRecognizer): OSErr;
  291.     {$IFC NOT GENERATINGCFM}
  292.     INLINE $303C, $020D, $AA56;
  293.     {$ENDC}
  294. FUNCTION SRSetLanguageModel(recognizer: SRRecognizer; languageModel: SRLanguageModel): OSErr;
  295.     {$IFC NOT GENERATINGCFM}
  296.     INLINE $303C, $040E, $AA56;
  297.     {$ENDC}
  298. FUNCTION SRGetLanguageModel(recognizer: SRRecognizer; VAR languageModel: SRLanguageModel): OSErr;
  299.     {$IFC NOT GENERATINGCFM}
  300.     INLINE $303C, $040F, $AA56;
  301.     {$ENDC}
  302. FUNCTION SRContinueRecognition(recognizer: SRRecognizer): OSErr;
  303.     {$IFC NOT GENERATINGCFM}
  304.     INLINE $303C, $0210, $AA56;
  305.     {$ENDC}
  306. FUNCTION SRCancelRecognition(recognizer: SRRecognizer): OSErr;
  307.     {$IFC NOT GENERATINGCFM}
  308.     INLINE $303C, $0211, $AA56;
  309.     {$ENDC}
  310. FUNCTION SRIdle: OSErr;
  311.     {$IFC NOT GENERATINGCFM}
  312.     INLINE $303C, $0028, $AA56;
  313.     {$ENDC}
  314. {  Language Model Building and Manipulation Functions  }
  315. FUNCTION SRNewLanguageModel(system: SRRecognitionSystem; VAR model: SRLanguageModel; name: UNIV Ptr; nameLength: Size): OSErr;
  316.     {$IFC NOT GENERATINGCFM}
  317.     INLINE $303C, $0812, $AA56;
  318.     {$ENDC}
  319. FUNCTION SRNewPath(system: SRRecognitionSystem; VAR path: SRPath): OSErr;
  320.     {$IFC NOT GENERATINGCFM}
  321.     INLINE $303C, $0413, $AA56;
  322.     {$ENDC}
  323. FUNCTION SRNewPhrase(system: SRRecognitionSystem; VAR phrase: SRPhrase; text: UNIV Ptr; textLength: Size): OSErr;
  324.     {$IFC NOT GENERATINGCFM}
  325.     INLINE $303C, $0814, $AA56;
  326.     {$ENDC}
  327. FUNCTION SRNewWord(system: SRRecognitionSystem; VAR word: SRWord; text: UNIV Ptr; textLength: Size): OSErr;
  328.     {$IFC NOT GENERATINGCFM}
  329.     INLINE $303C, $0815, $AA56;
  330.     {$ENDC}
  331. {  Operations on any object of the SRLanguageObject family  }
  332. FUNCTION SRPutLanguageObjectIntoHandle(languageObject: SRLanguageObject; lobjHandle: Handle): OSErr;
  333.     {$IFC NOT GENERATINGCFM}
  334.     INLINE $303C, $0416, $AA56;
  335.     {$ENDC}
  336. FUNCTION SRPutLanguageObjectIntoDataFile(languageObject: SRLanguageObject; fRefNum: INTEGER): OSErr;
  337.     {$IFC NOT GENERATINGCFM}
  338.     INLINE $303C, $0328, $AA56;
  339.     {$ENDC}
  340. FUNCTION SRNewLanguageObjectFromHandle(system: SRRecognitionSystem; VAR languageObject: SRLanguageObject; lObjHandle: Handle): OSErr;
  341.     {$IFC NOT GENERATINGCFM}
  342.     INLINE $303C, $0417, $AA56;
  343.     {$ENDC}
  344. FUNCTION SRNewLanguageObjectFromDataFile(system: SRRecognitionSystem; VAR languageObject: SRLanguageObject; fRefNum: INTEGER): OSErr;
  345.     {$IFC NOT GENERATINGCFM}
  346.     INLINE $303C, $0427, $AA56;
  347.     {$ENDC}
  348. FUNCTION SREmptyLanguageObject(languageObject: SRLanguageObject): OSErr;
  349.     {$IFC NOT GENERATINGCFM}
  350.     INLINE $303C, $0218, $AA56;
  351.     {$ENDC}
  352. FUNCTION SRChangeLanguageObject(languageObject: SRLanguageObject; text: UNIV Ptr; textLength: Size): OSErr;
  353.     {$IFC NOT GENERATINGCFM}
  354.     INLINE $303C, $0619, $AA56;
  355.     {$ENDC}
  356. FUNCTION SRAddLanguageObject(base: SRLanguageObject; addon: SRLanguageObject): OSErr;
  357.     {$IFC NOT GENERATINGCFM}
  358.     INLINE $303C, $041A, $AA56;
  359.     {$ENDC}
  360. FUNCTION SRAddText(base: SRLanguageObject; text: UNIV Ptr; textLength: Size; refCon: LONGINT): OSErr;
  361.     {$IFC NOT GENERATINGCFM}
  362.     INLINE $303C, $081B, $AA56;
  363.     {$ENDC}
  364. FUNCTION SRRemoveLanguageObject(base: SRLanguageObject; toRemove: SRLanguageObject): OSErr;
  365.     {$IFC NOT GENERATINGCFM}
  366.     INLINE $303C, $041C, $AA56;
  367.     {$ENDC}
  368. {  Traversing SRRecognitionResults or SRLanguageObjects  }
  369. FUNCTION SRCountItems(container: SRSpeechObject; VAR count: LONGINT): OSErr;
  370.     {$IFC NOT GENERATINGCFM}
  371.     INLINE $303C, $0405, $AA56;
  372.     {$ENDC}
  373. FUNCTION SRGetIndexedItem(container: SRSpeechObject; VAR item: SRSpeechObject; index: LONGINT): OSErr;
  374.     {$IFC NOT GENERATINGCFM}
  375.     INLINE $303C, $0606, $AA56;
  376.     {$ENDC}
  377. FUNCTION SRSetIndexedItem(container: SRSpeechObject; item: SRSpeechObject; index: LONGINT): OSErr;
  378.     {$IFC NOT GENERATINGCFM}
  379.     INLINE $303C, $0607, $AA56;
  380.     {$ENDC}
  381. FUNCTION SRRemoveIndexedItem(container: SRSpeechObject; index: LONGINT): OSErr;
  382.     {$IFC NOT GENERATINGCFM}
  383.     INLINE $303C, $0408, $AA56;
  384.     {$ENDC}
  385. {  Utilizing the System Feedback Window  }
  386. FUNCTION SRDrawText(recognizer: SRRecognizer; dispText: UNIV Ptr; dispLength: Size): OSErr;
  387.     {$IFC NOT GENERATINGCFM}
  388.     INLINE $303C, $0621, $AA56;
  389.     {$ENDC}
  390. FUNCTION SRDrawRecognizedText(recognizer: SRRecognizer; dispText: UNIV Ptr; dispLength: Size): OSErr;
  391.     {$IFC NOT GENERATINGCFM}
  392.     INLINE $303C, $0622, $AA56;
  393.     {$ENDC}
  394. FUNCTION SRSpeakText(recognizer: SRRecognizer; speakText: UNIV Ptr; speakLength: Size): OSErr;
  395.     {$IFC NOT GENERATINGCFM}
  396.     INLINE $303C, $0620, $AA56;
  397.     {$ENDC}
  398. FUNCTION SRSpeakAndDrawText(recognizer: SRRecognizer; text: UNIV Ptr; textLength: Size): OSErr;
  399.     {$IFC NOT GENERATINGCFM}
  400.     INLINE $303C, $061F, $AA56;
  401.     {$ENDC}
  402. FUNCTION SRStopSpeech(recognizer: SRRecognizer): OSErr;
  403.     {$IFC NOT GENERATINGCFM}
  404.     INLINE $303C, $0223, $AA56;
  405.     {$ENDC}
  406. FUNCTION SRSpeechBusy(recognizer: SRRecognizer): BOOLEAN;
  407.     {$IFC NOT GENERATINGCFM}
  408.     INLINE $303C, $0224, $AA56;
  409.     {$ENDC}
  410. FUNCTION SRProcessBegin(recognizer: SRRecognizer; failed: BOOLEAN): OSErr;
  411.     {$IFC NOT GENERATINGCFM}
  412.     INLINE $303C, $031D, $AA56;
  413.     {$ENDC}
  414. FUNCTION SRProcessEnd(recognizer: SRRecognizer; failed: BOOLEAN): OSErr;
  415.     {$IFC NOT GENERATINGCFM}
  416.     INLINE $303C, $031E, $AA56;
  417.     {$ENDC}
  418. {$ALIGN RESET}
  419. {$POP}
  420.  
  421. {$SETC UsingIncludes := SpeechRecognitionIncludes}
  422.  
  423. {$ENDC} {__SPEECHRECOGNITION__}
  424.  
  425. {$IFC NOT UsingIncludes}
  426.  END.
  427. {$ENDC}
  428.